#!/usr/bin/env python3
"""
自定义精简优化器
专门用于应用用户指定的30个核心列
"""

import pandas as pd
import os
import json
import logging
from datetime import datetime
from utils import optimize_analysis_data, _optimize_data_quality

# 设置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def get_custom_essential_columns():
    """
    获取用户指定的30个核心列
    """
    return [
        '时间', '开盘价', '最高价', '最低价', '收盘价', '成交量',
        '5日指数均线', 'RSI相对强弱指数', 'MACD快慢线差值', 'MACD信号线',
        '布林带上轨', '布林带中轨', '布林带下轨', 'KDJ_K值', 'KDJ_D值',
        '真实波动幅度', '商品通道指数', '威廉指标', '随机RSI_K', '变动率指标',
        '动量指标', '恐慌贪婪指数', '市场情绪', '市场强度', '价格位置百分比',
        '能量潮指标', '成交量加权均价', 'VWAP偏离度', '资金流量指数', '20日历史波动率'
    ]

def optimize_to_custom_essential(df):
    """
    优化数据到自定义精简列表
    :param df: 原始分析数据DataFrame
    :return: 优化后的DataFrame
    """
    if df.empty:
        logger.warning("输入数据为空，无法优化")
        return df
    
    logger.info(f"开始自定义精简优化")
    logger.info(f"原始数据: {len(df)} 行 × {len(df.columns)} 列")
    
    # 获取目标列
    target_columns = get_custom_essential_columns()
    
    # 过滤存在的列
    available_columns = [col for col in target_columns if col in df.columns]
    missing_columns = [col for col in target_columns if col not in df.columns]
    
    if missing_columns:
        logger.warning(f"以下列在数据中不存在: {missing_columns}")
        print(f"⚠️ 缺失的列 ({len(missing_columns)}个):")
        for i, col in enumerate(missing_columns, 1):
            print(f"   {i:2d}. {col}")
    
    if available_columns:
        print(f"✅ 可用的列 ({len(available_columns)}个):")
        for i, col in enumerate(available_columns, 1):
            print(f"   {i:2d}. {col}")
    
    # 创建优化后的数据
    optimized_df = df[available_columns].copy()
    
    # 数据质量优化
    optimized_df = _optimize_data_quality(optimized_df)
    
    compression_ratio = (1 - len(optimized_df.columns) / len(df.columns)) * 100
    
    logger.info(f"优化完成: {len(optimized_df)} 行 × {len(optimized_df.columns)} 列")
    logger.info(f"数据压缩率: {compression_ratio:.1f}%")
    
    return optimized_df

def check_ta_lib_requirements():
    """
    检查TA-Lib计算是否满足用户需求
    """
    print("🔍 检查TA-Lib计算配置...")
    print("-" * 60)
    
    required_indicators = {
        '5日指数均线': 'EMA5 - 已在ta_calculator.py中计算',
        'RSI相对强弱指数': 'RSI - 已在ta_calculator.py中计算',
        'MACD快慢线差值': 'MACD - 已在ta_calculator.py中计算',
        'MACD信号线': 'MACD_SIGNAL - 已在ta_calculator.py中计算',
        '布林带上轨': 'BOLL_UPPER - 已在ta_calculator.py中计算',
        '布林带中轨': 'BOLL_MIDDLE - 已在ta_calculator.py中计算',
        '布林带下轨': 'BOLL_LOWER - 已在ta_calculator.py中计算',
        'KDJ_K值': 'KDJ_K - 已在ta_calculator.py中计算',
        'KDJ_D值': 'KDJ_D - 已在ta_calculator.py中计算',
        '真实波动幅度': 'ATR - 已在ta_calculator.py中计算',
        '商品通道指数': 'CCI - 已在ta_calculator.py中计算',
        '威廉指标': 'WILLR - 已在ta_calculator.py中计算',
        '随机RSI_K': 'STOCH_RSI_K - 已在ta_calculator.py中计算',
        '变动率指标': 'ROC - 已在ta_calculator.py中计算',
        '动量指标': 'MOM - 已在ta_calculator.py中计算',
        '恐慌贪婪指数': 'FEAR_GREED_INDEX - 已在ta_calculator.py中计算',
        '市场情绪': 'MARKET_SENTIMENT - 已在ta_calculator.py中计算',
        '市场强度': 'MARKET_STRENGTH - 已在ta_calculator.py中计算',
        '价格位置百分比': 'PRICE_POSITION - 已在ta_calculator.py中计算',
        '能量潮指标': 'OBV - 已在ta_calculator.py中计算',
        '成交量加权均价': 'VWAP - 已在ta_calculator.py中计算',
        'VWAP偏离度': 'VWAP_DEVIATION - 已在ta_calculator.py中计算',
        '资金流量指数': 'MFI - 已在ta_calculator.py中计算',
        '20日历史波动率': 'HV_20 - 已在ta_calculator.py中计算'
    }
    
    print("📊 所需指标检查结果:")
    all_available = True
    
    for chinese_name, status in required_indicators.items():
        if "已在ta_calculator.py中计算" in status:
            print(f"✅ {chinese_name:15} - {status}")
        else:
            print(f"❌ {chinese_name:15} - {status}")
            all_available = False
    
    print("-" * 60)
    if all_available:
        print("🎉 所有需要的指标都已在TA-Lib计算中实现！")
        print("💡 无需修改ta_calculator.py，可以直接使用现有计算")
    else:
        print("⚠️ 部分指标需要在ta_calculator.py中添加")
    
    return all_available

def optimize_analysis_files():
    """
    批量优化分析文件到自定义精简格式
    """
    print("🚀 批量优化分析文件到自定义精简格式")
    print("=" * 70)
    
    # 查找分析文件
    analysis_files = [f for f in os.listdir('.') if f.endswith('_analysis.csv')]
    
    if not analysis_files:
        print("❌ 未找到analysis.csv文件")
        return
    
    print(f"📁 找到 {len(analysis_files)} 个分析文件")
    
    results = []
    
    for filename in analysis_files:
        print(f"\n📊 处理文件: {filename}")
        print("-" * 50)
        
        try:
            # 读取原始数据
            df = pd.read_csv(filename)
            original_size = len(df) * len(df.columns)
            
            print(f"原始数据: {len(df)} 行 × {len(df.columns)} 列")
            
            # 执行自定义优化
            optimized_df = optimize_to_custom_essential(df)
            
            if not optimized_df.empty:
                # 生成输出文件名
                timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
                base_name = filename.replace('_analysis.csv', '')
                output_filename = f"{base_name}_{timestamp}_custom_essential.csv"
                
                # 保存优化后的文件
                optimized_df.to_csv(output_filename, index=False, encoding='utf-8-sig')
                
                # 计算统计信息
                optimized_size = len(optimized_df) * len(optimized_df.columns)
                compression_ratio = (1 - optimized_size / original_size) * 100
                
                file_size_original = os.path.getsize(filename) / 1024
                file_size_optimized = os.path.getsize(output_filename) / 1024
                size_reduction = (1 - file_size_optimized / file_size_original) * 100
                
                result = {
                    'original_file': filename,
                    'optimized_file': output_filename,
                    'original_columns': len(df.columns),
                    'optimized_columns': len(optimized_df.columns),
                    'compression_ratio': compression_ratio,
                    'file_size_original': file_size_original,
                    'file_size_optimized': file_size_optimized,
                    'size_reduction': size_reduction
                }
                
                results.append(result)
                
                print(f"✅ 优化完成: {output_filename}")
                print(f"   数据压缩: {compression_ratio:.1f}%")
                print(f"   文件减小: {size_reduction:.1f}%")
                print(f"   保留列数: {len(optimized_df.columns)}")
            else:
                print("❌ 优化失败 - 返回空数据")
                
        except Exception as e:
            print(f"❌ 处理失败: {e}")
    
    # 生成总结报告
    if results:
        print(f"\n" + "=" * 70)
        print("📊 自定义精简优化总结")
        print("=" * 70)
        
        total_compression = sum(r['compression_ratio'] for r in results) / len(results)
        total_size_reduction = sum(r['size_reduction'] for r in results) / len(results)
        
        print(f"处理文件数: {len(results)}")
        print(f"平均数据压缩率: {total_compression:.1f}%")
        print(f"平均文件减小: {total_size_reduction:.1f}%")
        print(f"目标列数: 30列 (用户指定)")
        
        print(f"\n📋 详细结果:")
        for result in results:
            print(f"  {result['original_file']}:")
            print(f"    {result['original_columns']}列 → {result['optimized_columns']}列 (压缩{result['compression_ratio']:.1f}%)")
            print(f"    {result['file_size_original']:.1f}KB → {result['file_size_optimized']:.1f}KB (减小{result['size_reduction']:.1f}%)")
        
        # 保存详细报告
        report_filename = f"custom_essential_optimization_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
        with open(report_filename, 'w', encoding='utf-8') as f:
            json.dump({
                'optimization_type': 'custom_essential',
                'target_columns': get_custom_essential_columns(),
                'results': results,
                'summary': {
                    'total_files': len(results),
                    'average_compression': total_compression,
                    'average_size_reduction': total_size_reduction
                },
                'generated_at': datetime.now().isoformat()
            }, f, ensure_ascii=False, indent=2)
        
        print(f"\n📄 详细报告已保存: {report_filename}")

def main():
    """主函数"""
    print("🎯 自定义精简优化器")
    print("=" * 70)
    print("目标: 将analysis.csv文件精简到用户指定的30个核心列")
    print("=" * 70)
    
    # 1. 检查TA-Lib计算配置
    check_ta_lib_requirements()
    
    print()
    
    # 2. 显示目标列列表
    target_columns = get_custom_essential_columns()
    print(f"🎯 目标列列表 ({len(target_columns)}个):")
    print("-" * 50)
    for i, col in enumerate(target_columns, 1):
        print(f"{i:2d}. {col}")
    
    print()
    
    # 3. 执行批量优化
    optimize_analysis_files()
    
    print(f"\n" + "=" * 70)
    print("🎉 自定义精简优化完成！")
    print("💡 提示: 生成的文件名包含'custom_essential'标识")

if __name__ == "__main__":
    main()
